1、子数组最大和
思想：求数组中，子数组的最大和，
看到最大值，最小值等应该想到动态规划
动态规划；
第一步，找到子问题的定义
第二步，找到子问题和原问题的关系
第三步：找到返回值
第四步：初始化
基于此思想，容易得出子问题f(i),表示以i为结尾的子数组的最大值和，
依次计算出数组中所有以该下表为结尾的元素和的最大值，那么计算
f(i)=max(f(i-1)+a[i],a[i]）也就是第i个元素的最大值，一个可能是f(i-1)+a[i],另一个可能为a[i]本身自己，另外还可以利用2个变量，那样就不需要建立数组存储每个元素最大值

所以基于此思想，得出代码
class Solution {
public:
    /**
     * max sum of the subarray
     * @param arr int整型vector the array
     * @return int整型
     */
    int maxsumofSubarray(vector<int>& arr) {
        // write code here
        /*
        int len=arr.size();
        vector<int> v(len,0);
        v[0]=arr[0];
        for(int i=1;i<len;i++)
        {
            v[i]=max(v[i-1]+arr[i],arr[i]);
        }
        int m=v[0];
        for(int i=1;i<len;i++)
        {
            m=max(m,v[i]);
        }
        return m;
        /
        */
        int ret=arr[0];
        int m=arr[0];
        int len=arr.size();
        for(int i=1;i<len;i++)
        {
            m=max(m+arr[i],arr[i]);
            ret=max(m,ret);
        }
        return ret;
    }
};

2、机器人从最左边走到最右边的路径条数
思想：动态规划：
f(i,j)=f(i,j-1)+f(i-1,j)的位置过来，需要注意第一行以及第一列的路径只有一种。
初始化是注意  定义每个坐标的值为1这样每走一格就是一种方法，
class Solution {
public:
    /**
     * 
     * @param m int整型 
     * @param n int整型 
     * @return int整型
     */
    int uniquePaths(int m, int n) {
        // write code here
        vector<vector<int>> pathsum(m,vector<int>(n,1));
        pathsum[0][0]=1;
        for(int i=0;i<m;++i)
        {
            for(int j=0;j<n;j++)
            {
                //第一列
                if(j==0)
                {
                    pathsum[i][j]==1;
                }
                else if(i==0)
                {
                    pathsum[i][j]==1;
                }
                else
                {
                    pathsum[i][j]=pathsum[i][j-1]+pathsum[i-1][j];
                }
            }
        }
        return pathsum[m-1][n-1];
        
    }
};
3、机器人从最左到最由的最短路径
思想：动态规划，f(i,j)=min(f(i-1,j),f(i,j-1)),
class Solution {
public:
    /**
     * 
     * @param matrix int整型vector<vector<>> the matrix
     * @return int整型
     */
    int minPathSum(vector<vector<int> >& matrix) {
        // write code here
        int row=matrix.size();//行
        int col=matrix[0].size();//列、
        vector<vector<int>> minpathsum(row,vector<int>(col,0));
        minpathsum[0][0]=matrix[0][0];
        for(int i=1;i<row;i++)
        {
            minpathsum[i][0]=minpathsum[i-1][0]+matrix[i][0];
        }
        for(int i=1;i<col;i++)
        {
            minpathsum[0][i]=minpathsum[0][i-1]+matrix[0][i];
        }
        for(int i=1;i<row;i++)
        {
            for(int j=1;j<col;j++)
            {
                minpathsum[i][j]=min(minpathsum[i][j-1],minpathsum[i-1][j])+matrix[i][j];
            }
        }
        return minpathsum[row-1][col-1];
    }
};